home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung CD 2 (Tewi)(1994).iso / c / compcomp / byacc / output.c < prev    next >
C/C++ Source or Header  |  1990-12-15  |  22KB  |  1,147 lines
  1. #include "defs.h"
  2.  
  3. static int nvectors;
  4. static int nentries;
  5. static short **froms;
  6. static short **tos;
  7. static short *tally;
  8. static short *width;
  9. static short *state_count;
  10. static short *order;
  11. static short *base;
  12. static short *pos;
  13. static int maxtable;
  14. static short *table;
  15. static short *check;
  16. static int lowzero;
  17. static int high;
  18.  
  19.  
  20. output()
  21. {
  22.     free_itemsets();
  23.     free_shifts();
  24.     free_reductions();
  25.     output_stored_text();
  26.     output_defines();
  27.     output_rule_data();
  28.     output_yydefred();
  29.     output_actions();
  30.     free_parser();
  31.     output_debug();
  32.     output_stype();
  33.     if (rflag) write_section(tables);
  34.     write_section(header);
  35.     output_trailing_text();
  36.     write_section(body);
  37.     output_semantic_actions();
  38.     write_section(trailer);
  39. }
  40.  
  41.  
  42. output_rule_data()
  43. {
  44.     register int i;
  45.     register int j;
  46.  
  47.   
  48.     fprintf(output_file, "short yylhs[] = {%42d,",
  49.         symbol_value[start_symbol]);
  50.  
  51.     j = 10;
  52.     for (i = 3; i < nrules; i++)
  53.     {
  54.     if (j >= 10)
  55.     {
  56.         if (!rflag) ++outline;
  57.         putc('\n', output_file);
  58.         j = 1;
  59.     }
  60.         else
  61.         ++j;
  62.  
  63.         fprintf(output_file, "%5d,", symbol_value[rlhs[i]]);
  64.     }
  65.     if (!rflag) outline += 2;
  66.     fprintf(output_file, "\n};\n");
  67.  
  68.     fprintf(output_file, "short yylen[] = {%42d,", 2);
  69.  
  70.     j = 10;
  71.     for (i = 3; i < nrules; i++)
  72.     {
  73.     if (j >= 10)
  74.     {
  75.         if (!rflag) ++outline;
  76.         putc('\n', output_file);
  77.         j = 1;
  78.     }
  79.     else
  80.       j++;
  81.  
  82.         fprintf(output_file, "%5d,", rrhs[i + 1] - rrhs[i] - 1);
  83.     }
  84.     if (!rflag) outline += 2;
  85.     fprintf(output_file, "\n};\n");
  86. }
  87.  
  88.  
  89. output_yydefred()
  90. {
  91.     register int i, j;
  92.  
  93.     fprintf(output_file, "short yydefred[] = {%39d,",
  94.         (defred[0] ? defred[0] - 2 : 0));
  95.  
  96.     j = 10;
  97.     for (i = 1; i < nstates; i++)
  98.     {
  99.     if (j < 10)
  100.         ++j;
  101.     else
  102.     {
  103.         if (!rflag) ++outline;
  104.         putc('\n', output_file);
  105.         j = 1;
  106.     }
  107.  
  108.     fprintf(output_file, "%5d,", (defred[i] ? defred[i] - 2 : 0));
  109.     }
  110.  
  111.     if (!rflag) outline += 2;
  112.     fprintf(output_file, "\n};\n");
  113. }
  114.  
  115.  
  116. output_actions()
  117. {
  118.     nvectors = 2*nstates + nvars;
  119.  
  120.     froms = NEW2(nvectors, short *);
  121.     tos = NEW2(nvectors, short *);
  122.     tally = NEW2(nvectors, short);
  123.     width = NEW2(nvectors, short);
  124.  
  125.     token_actions();
  126.     FREE(lookaheads);
  127.     FREE(LA);
  128.     FREE(LAruleno);
  129.     FREE(accessing_symbol);
  130.  
  131.     goto_actions();
  132.     FREE(goto_map + ntokens);
  133.     FREE(from_state);
  134.     FREE(to_state);
  135.  
  136.     sort_actions();
  137.     pack_table();
  138.     output_base();
  139.     output_table();
  140.     output_check();
  141. }
  142.  
  143.  
  144. token_actions()
  145. {
  146.     register int i, j;
  147.     register int shiftcount, reducecount;
  148.     register int max, min;
  149.     register short *actionrow, *r, *s;
  150.     register action *p;
  151.  
  152.     actionrow = NEW2(2*ntokens, short);
  153.     for (i = 0; i < nstates; ++i)
  154.     {
  155.     if (parser[i])
  156.     {
  157.         for (j = 0; j < 2*ntokens; ++j)
  158.         actionrow[j] = 0;
  159.  
  160.         shiftcount = 0;
  161.         reducecount = 0;
  162.         for (p = parser[i]; p; p = p->next)
  163.         {
  164.         if (p->suppressed == 0)
  165.         {
  166.             if (p->action_code == SHIFT)
  167.             {
  168.             ++shiftcount;
  169.             actionrow[p->symbol] = p->number;
  170.             }
  171.             else if (p->action_code == REDUCE && p->number != defred[i])
  172.             {
  173.             ++reducecount;
  174.             actionrow[p->symbol + ntokens] = p->number;
  175.             }
  176.         }
  177.         }
  178.  
  179.         tally[i] = shiftcount;
  180.         tally[nstates+i] = reducecount;
  181.         width[i] = 0;
  182.         width[nstates+i] = 0;
  183.         if (shiftcount > 0)
  184.         {
  185.         froms[i] = r = NEW2(shiftcount, short);
  186.         tos[i] = s = NEW2(shiftcount, short);
  187.         min = MAXSHORT;
  188.         max = 0;
  189.         for (j = 0; j < ntokens; ++j)
  190.         {
  191.             if (actionrow[j])
  192.             {
  193.             if (min > symbol_value[j])
  194.                 min = symbol_value[j];
  195.             if (max < symbol_value[j])
  196.                 max = symbol_value[j];
  197.             *r++ = symbol_value[j];
  198.             *s++ = actionrow[j];
  199.             }
  200.         }
  201.         width[i] = max - min + 1;
  202.         }
  203.         if (reducecount > 0)
  204.         {
  205.         froms[nstates+i] = r = NEW2(reducecount, short);
  206.         tos[nstates+i] = s = NEW2(reducecount, short);
  207.         min = MAXSHORT;
  208.         max = 0;
  209.         for (j = 0; j < ntokens; ++j)
  210.         {
  211.             if (actionrow[ntokens+j])
  212.             {
  213.             if (min > symbol_value[j])
  214.                 min = symbol_value[j];
  215.             if (max < symbol_value[j])
  216.                 max = symbol_value[j];
  217.             *r++ = symbol_value[j];
  218.             *s++ = actionrow[ntokens+j] - 2;
  219.             }
  220.         }
  221.         width[nstates+i] = max - min + 1;
  222.         }
  223.     }
  224.     }
  225.     FREE(actionrow);
  226. }
  227.  
  228. goto_actions()
  229. {
  230.     register int i, j, k;
  231.  
  232.     state_count = NEW2(nstates, short);
  233.  
  234.     k = default_goto(start_symbol + 1);
  235.     fprintf(output_file, "short yydgoto[] = {%40d,", k);
  236.     save_column(start_symbol + 1, k);
  237.  
  238.     j = 10;
  239.     for (i = start_symbol + 2; i < nsyms; i++)
  240.     {
  241.     if (j >= 10)
  242.     {
  243.         if (!rflag) ++outline;
  244.         putc('\n', output_file);
  245.         j = 1;
  246.     }
  247.     else
  248.         ++j;
  249.  
  250.     k = default_goto(i);
  251.     fprintf(output_file, "%5d,", k);
  252.     save_column(i, k);
  253.     }
  254.  
  255.     if (!rflag) outline += 2;
  256.     fprintf(output_file, "\n};\n");
  257.     FREE(state_count);
  258. }
  259.  
  260. int
  261. default_goto(symbol)
  262. int symbol;
  263. {
  264.     register int i;
  265.     register int m;
  266.     register int n;
  267.     register int default_state;
  268.     register int max;
  269.  
  270.     m = goto_map[symbol];
  271.     n = goto_map[symbol + 1];
  272.  
  273.     if (m == n) return (0);
  274.  
  275.     for (i = 0; i < nstates; i++)
  276.     state_count[i] = 0;
  277.  
  278.     for (i = m; i < n; i++)
  279.     state_count[to_state[i]]++;
  280.  
  281.     max = 0;
  282.     default_state = 0;
  283.     for (i = 0; i < nstates; i++)
  284.     {
  285.     if (state_count[i] > max)
  286.     {
  287.         max = state_count[i];
  288.         default_state = i;
  289.     }
  290.     }
  291.  
  292.     return (default_state);
  293. }
  294.  
  295.  
  296.  
  297. save_column(symbol, default_state)
  298. int symbol;
  299. int default_state;
  300. {
  301.     register int i;
  302.     register int m;
  303.     register int n;
  304.     register short *sp;
  305.     register short *sp1;
  306.     register short *sp2;
  307.     register int count;
  308.     register int symno;
  309.  
  310.     m = goto_map[symbol];
  311.     n = goto_map[symbol + 1];
  312.  
  313.     count = 0;
  314.     for (i = m; i < n; i++)
  315.     {
  316.     if (to_state[i] != default_state)
  317.         ++count;
  318.     }
  319.     if (count == 0) return;
  320.  
  321.     symno = symbol_value[symbol] + 2*nstates;
  322.  
  323.     froms[symno] = sp1 = sp = NEW2(count, short);
  324.     tos[symno] = sp2 = NEW2(count, short);
  325.  
  326.     for (i = m; i < n; i++)
  327.     {
  328.     if (to_state[i] != default_state)
  329.     {
  330.         *sp1++ = from_state[i];
  331.         *sp2++ = to_state[i];
  332.     }
  333.     }
  334.  
  335.     tally[symno] = count;
  336.     width[symno] = sp1[-1] - sp[0] + 1;
  337. }
  338.  
  339. sort_actions()
  340. {
  341.   register int i;
  342.   register int j;
  343.   register int k;
  344.   register int t;
  345.   register int w;
  346.  
  347.   order = NEW2(nvectors, short);
  348.   nentries = 0;
  349.  
  350.   for (i = 0; i < nvectors; i++)
  351.     {
  352.       if (tally[i] > 0)
  353.     {
  354.       t = tally[i];
  355.       w = width[i];
  356.       j = nentries - 1;
  357.  
  358.       while (j >= 0 && (width[order[j]] < w))
  359.         j--;
  360.  
  361.       while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
  362.         j--;
  363.  
  364.       for (k = nentries - 1; k > j; k--)
  365.         order[k + 1] = order[k];
  366.  
  367.       order[j + 1] = i;
  368.       nentries++;
  369.     }
  370.     }
  371. }
  372.  
  373.  
  374. pack_table()
  375. {
  376.     register int i;
  377.     register int place;
  378.     register int state;
  379.  
  380.     base = NEW2(nvectors, short);
  381.     pos = NEW2(nentries, short);
  382.  
  383.     maxtable = 1000;
  384.     table = NEW2(maxtable, short);
  385.     check = NEW2(maxtable, short);
  386.  
  387.     lowzero = 0;
  388.     high = 0;
  389.  
  390.     for (i = 0; i < maxtable; i++)
  391.     check[i] = -1;
  392.  
  393.     for (i = 0; i < nentries; i++)
  394.     {
  395.     state = matching_vector(i);
  396.  
  397.     if (state < 0)
  398.         place = pack_vector(i);
  399.     else
  400.         place = base[state];
  401.  
  402.     pos[i] = place;
  403.     base[order[i]] = place;
  404.     }
  405.  
  406.     for (i = 0; i < nvectors; i++)
  407.     {
  408.     if (froms[i])
  409.         FREE(froms[i]);
  410.     if (tos[i])
  411.         FREE(tos[i]);
  412.     }
  413.  
  414.     FREE(froms);
  415.     FREE(tos);
  416.     FREE(pos);
  417. }
  418.  
  419.  
  420. /*  The function matching_vector determines if the vector specified by    */
  421. /*  the input parameter matches a previously considered    vector.  The    */
  422. /*  test at the start of the function checks if the vector represents    */
  423. /*  a row of shifts over terminal symbols or a row of reductions, or a    */
  424. /*  column of shifts over a nonterminal symbol.  Berkeley Yacc does not    */
  425. /*  check if a column of shifts over a nonterminal symbols matches a    */
  426. /*  previously considered vector.  Because of the nature of LR parsing    */
  427. /*  tables, no two columns can match.  Therefore, the only possible    */
  428. /*  match would be between a row and a column.  Such matches are    */
  429. /*  unlikely.  Therefore, to save time, no attempt is made to see if a    */
  430. /*  column matches a previously considered vector.            */
  431. /*                                    */
  432. /*  Matching_vector is poorly designed.  The test could easily be made    */
  433. /*  faster.  Also, it depends on the vectors being in a specific    */
  434. /*  order.                                */
  435.  
  436. int
  437. matching_vector(vector)
  438. int vector;
  439. {
  440.     register int i;
  441.     register int j;
  442.     register int k;
  443.     register int t;
  444.     register int w;
  445.     register int match;
  446.     register int prev;
  447.  
  448.     i = order[vector];
  449.     if (i >= 2*nstates)
  450.     return (-1);
  451.  
  452.     t = tally[i];
  453.     w = width[i];
  454.  
  455.     for (prev = vector - 1; prev >= 0; prev--)
  456.     {
  457.     j = order[prev];
  458.     if (width[j] != w || tally[j] != t)
  459.         return (-1);
  460.  
  461.     match = 1;
  462.     for (k = 0; match && k < t; k++)
  463.     {
  464.         if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
  465.         match = 0;
  466.     }
  467.  
  468.     if (match)
  469.         return (j);
  470.     }
  471.  
  472.     return (-1);
  473. }
  474.  
  475.  
  476.  
  477. int
  478. pack_vector(vector)
  479. int vector;
  480. {
  481.     register int i, j, k, l;
  482.     register int t;
  483.     register int loc;
  484.     register int ok;
  485.     register short *from;
  486.     register short *to;
  487.     int newmax;
  488.  
  489.     i = order[vector];
  490.     t = tally[i];
  491.     assert(t);
  492.  
  493.     from = froms[i];
  494.     to = tos[i];
  495.  
  496.     j = lowzero - from[0];
  497.     for (k = 1; k < t; ++k)
  498.     if (lowzero - from[k] > j)
  499.         j = lowzero - from[k];
  500.     for (;; ++j)
  501.     {
  502.     if (j == 0)
  503.         continue;
  504.     ok = 1;
  505.     for (k = 0; ok && k < t; k++)
  506.     {
  507.         loc = j + from[k];
  508.         if (loc >= maxtable)
  509.         {
  510.         if (loc >= MAXTABLE)
  511.             fatal("maximum table size exceeded");
  512.  
  513.         newmax = maxtable;
  514.         do { newmax += 200; } while (newmax <= loc);
  515.         table = (short *) REALLOC(table, newmax*sizeof(short));
  516.         if (table == 0) no_space();
  517.         check = (short *) REALLOC(check, newmax*sizeof(short));
  518.         if (check == 0) no_space();
  519.         for (l  = maxtable; l < newmax; ++l)
  520.         {
  521.             table[l] = 0;
  522.             check[l] = -1;
  523.         }
  524.         maxtable = newmax;
  525.         }
  526.  
  527.         if (check[loc] != -1)
  528.         ok = 0;
  529.     }
  530.     for (k = 0; ok && k < vector; k++)
  531.     {
  532.         if (pos[k] == j)
  533.         ok = 0;
  534.     }
  535.     if (ok)
  536.     {
  537.         for (k = 0; k < t; k++)
  538.         {
  539.         loc = j + from[k];
  540.         table[loc] = to[k];
  541.         check[loc] = from[k];
  542.         if (loc > high) high = loc;
  543.         }
  544.  
  545.         while (check[lowzero] != -1)
  546.         ++lowzero;
  547.  
  548.         return (j);
  549.     }
  550.     }
  551. }
  552.  
  553.  
  554.  
  555. output_base()
  556. {
  557.     register int i, j;
  558.  
  559.     fprintf(output_file, "short yysindex[] = {%39d,", base[0]);
  560.  
  561.     j = 10;
  562.     for (i = 1; i < nstates; i++)
  563.     {
  564.     if (j >= 10)
  565.     {
  566.         if (!rflag) ++outline;
  567.         putc('\n', output_file);
  568.         j = 1;
  569.     }
  570.     else
  571.         ++j;
  572.  
  573.     fprintf(output_file, "%5d,", base[i]);
  574.     }
  575.  
  576.     if (!rflag) outline += 2;
  577.     fprintf(output_file, "\n};\nshort yyrindex[] = {%39d,",
  578.         base[nstates]);
  579.  
  580.     j = 10;
  581.     for (i = nstates + 1; i < 2*nstates; i++)
  582.     {
  583.     if (j >= 10)
  584.     {
  585.         if (!rflag) ++outline;
  586.         putc('\n', output_file);
  587.         j = 1;
  588.     }
  589.     else
  590.         ++j;
  591.  
  592.     fprintf(output_file, "%5d,", base[i]);
  593.     }
  594.  
  595.     if (!rflag) outline += 2;
  596.     fprintf(output_file, "\n};\nshort yygindex[] = {%39d,",
  597.         base[2*nstates]);
  598.  
  599.     j = 10;
  600.     for (i = 2*nstates + 1; i < nvectors - 1; i++)
  601.     {
  602.     if (j >= 10)
  603.     {
  604.         if (!rflag) ++outline;
  605.         putc('\n', output_file);
  606.         j = 1;
  607.     }
  608.     else
  609.         ++j;
  610.  
  611.     fprintf(output_file, "%5d,", base[i]);
  612.     }
  613.  
  614.     if (!rflag) outline += 2;
  615.     fprintf(output_file, "\n};\n");
  616.     FREE(base);
  617. }
  618.  
  619.  
  620.  
  621. output_table()
  622. {
  623.     register int i;
  624.     register int j;
  625.  
  626.     ++outline;
  627.     fprintf(code_file, "#define YYTABLESIZE %d\n", high);
  628.     fprintf(output_file, "short yytable[] = {%40d,", table[0]);
  629.  
  630.     j = 10;
  631.     for (i = 1; i <= high; i++)
  632.     {
  633.     if (j >= 10)
  634.     {
  635.         if (!rflag) ++outline;
  636.         putc('\n', output_file);
  637.         j = 1;
  638.     }
  639.     else
  640.         ++j;
  641.  
  642.     fprintf(output_file, "%5d,", table[i]);
  643.     }
  644.  
  645.     if (!rflag) outline += 2;
  646.     fprintf(output_file, "\n};\n");
  647.     FREE(table);
  648. }
  649.  
  650.  
  651.  
  652. output_check()
  653. {
  654.     register int i;
  655.     register int j;
  656.  
  657.     fprintf(output_file, "short yycheck[] = {%40d,", check[0]);
  658.  
  659.     j = 10;
  660.     for (i = 1; i <= high; i++)
  661.     {
  662.     if (j >= 10)
  663.     {
  664.         if (!rflag) ++outline;
  665.         putc('\n', output_file);
  666.         j = 1;
  667.     }
  668.     else
  669.         ++j;
  670.  
  671.     fprintf(output_file, "%5d,", check[i]);
  672.     }
  673.  
  674.     if (!rflag) outline += 2;
  675.     fprintf(output_file, "\n};\n");
  676.     FREE(check);
  677. }
  678.  
  679.  
  680. int
  681. is_C_identifier(name)
  682. char *name;
  683. {
  684.     register char *s;
  685.     register int c;
  686.  
  687.     s = name;
  688.     c = *s;
  689.     if (c == '"')
  690.     {
  691.     c = *++s;
  692.     if (!isalpha(c) && c != '_' && c != '$')
  693.         return (0);
  694.     while ((c = *++s) != '"')
  695.     {
  696.         if (!isalnum(c) && c != '_' && c != '$')
  697.         return (0);
  698.     }
  699.     return (1);
  700.     }
  701.  
  702.     if (!isalpha(c) && c != '_' && c != '$')
  703.     return (0);
  704.     while (c = *++s)
  705.     {
  706.     if (!isalnum(c) && c != '_' && c != '$')
  707.         return (0);
  708.     }
  709.     return (1);
  710. }
  711.  
  712.  
  713. output_defines()
  714. {
  715.     register int c, i;
  716.     register char *s;
  717.  
  718.     for (i = 2; i < ntokens; ++i)
  719.     {
  720.     s = symbol_name[i];
  721.     if (is_C_identifier(s))
  722.     {
  723.         fprintf(code_file, "#define ");
  724.         if (dflag) fprintf(defines_file, "#define ");
  725.         c = *s;
  726.         if (c == '"')
  727.         {
  728.         while ((c = *++s) != '"')
  729.         {
  730.             putc(c, code_file);
  731.             if (dflag) putc(c, defines_file);
  732.         }
  733.         }
  734.         else
  735.         {
  736.         do
  737.         {
  738.             putc(c, code_file);
  739.             if (dflag) putc(c, defines_file);
  740.         }
  741.         while (c = *++s);
  742.         }
  743.         ++outline;
  744.         fprintf(code_file, " %d\n", symbol_value[i]);
  745.         if (dflag) fprintf(defines_file, " %d\n", symbol_value[i]);
  746.     }
  747.     }
  748.  
  749.     ++outline;
  750.     fprintf(code_file, "#define YYERRCODE %d\n", symbol_value[1]);
  751.  
  752.     if (dflag && unionized)
  753.     {
  754.     fclose(union_file);
  755.     union_file = fopen(union_file_name, "r");
  756.     if (union_file == NULL) open_error(union_file_name);
  757.     while ((c = getc(union_file)) != EOF)
  758.         putc(c, defines_file);
  759.     fprintf(defines_file, " YYSTYPE;\nextern YYSTYPE yylval;\n");
  760.     }
  761. }
  762.  
  763.  
  764. output_stored_text()
  765. {
  766.     register int c;
  767.     register FILE *in, *out;
  768.  
  769.     fclose(text_file);
  770.     text_file = fopen(text_file_name, "r");
  771.     if (text_file == NULL)
  772.     open_error(text_file_name);
  773.     in = text_file;
  774.     if ((c = getc(in)) == EOF)
  775.     return;
  776.     out = code_file;
  777.     if (c ==  '\n')
  778.     ++outline;
  779.     putc(c, out);
  780.     while ((c = getc(in)) != EOF)
  781.     {
  782.     if (c == '\n')
  783.         ++outline;
  784.     putc(c, out);
  785.     }
  786.     if (!lflag)
  787.     fprintf(out, line_format, ++outline + 1, code_file_name);
  788. }
  789.  
  790.  
  791. output_debug()
  792. {
  793.     register int i, j, k, max;
  794.     char **symnam, *s;
  795.  
  796.     ++outline;
  797.     fprintf(code_file, "#define YYFINAL %d\n", final_state);
  798.     outline += 3;
  799.     fprintf(code_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n",
  800.         tflag);
  801.     if (rflag)
  802.     fprintf(output_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n",
  803.         tflag);
  804.  
  805.     max = 0;
  806.     for (i = 2; i < ntokens; ++i)
  807.     if (symbol_value[i] > max)
  808.         max = symbol_value[i];
  809.     ++outline;
  810.     fprintf(code_file, "#define YYMAXTOKEN %d\n", max);
  811.  
  812.     symnam = (char **) MALLOC((max+1)*sizeof(char *));
  813.     if (symnam == 0) no_space();
  814.  
  815.     /* Note that it is  not necessary to initialize the element        */
  816.     /* symnam[max].                            */
  817.     for (i = 0; i < max; ++i)
  818.     symnam[i] = 0;
  819.     for (i = ntokens - 1; i >= 2; --i)
  820.     symnam[symbol_value[i]] = symbol_name[i];
  821.     symnam[0] = "end-of-file";
  822.  
  823.     if (!rflag) ++outline;
  824.     fprintf(output_file, "#if YYDEBUG\nchar *yyname[] = {");
  825.     j = 80;
  826.     for (i = 0; i <= max; ++i)
  827.     {
  828.     if (s = symnam[i])
  829.     {
  830.         if (s[0] == '"')
  831.         {
  832.         k = 7;
  833.         while (*++s != '"')
  834.         {
  835.             ++k;
  836.             if (*s == '\\')
  837.             {
  838.             k += 2;
  839.             if (*++s == '\\')
  840.                 ++k;
  841.             }
  842.         }
  843.         j += k;
  844.         if (j > 80)
  845.         {
  846.             if (!rflag) ++outline;
  847.             putc('\n', output_file);
  848.             j = k;
  849.         }
  850.         fprintf(output_file, "\"\\\"");
  851.         s = symnam[i];
  852.         while (*++s != '"')
  853.         {
  854.             if (*s == '\\')
  855.             {
  856.             fprintf(output_file, "\\\\");
  857.             if (*++s == '\\')
  858.                 fprintf(output_file, "\\\\");
  859.             else
  860.                 putc(*s, output_file);
  861.             }
  862.             else
  863.             putc(*s, output_file);
  864.         }
  865.         fprintf(output_file, "\\\"\",");
  866.         }
  867.         else if (s[0] == '\'')
  868.         {
  869.         if (s[1] == '"')
  870.         {
  871.             j += 7;
  872.             if (j > 80)
  873.             {
  874.             if (!rflag) ++outline;
  875.             putc('\n', output_file);
  876.             j = 7;
  877.             }
  878.             fprintf(output_file, "\"'\\\"'\",");
  879.         }
  880.         else
  881.         {
  882.             k = 5;
  883.             while (*++s != '\'')
  884.             {
  885.             ++k;
  886.             if (*s == '\\')
  887.             {
  888.                 k += 2;
  889.                 if (*++s == '\\')
  890.                 ++k;
  891.             }
  892.             }
  893.             j += k;
  894.             if (j > 80)
  895.             {
  896.             if (!rflag) ++outline;
  897.             putc('\n', output_file);
  898.             j = k;
  899.             }
  900.             fprintf(output_file, "\"'");
  901.             s = symnam[i];
  902.             while (*++s != '\'')
  903.             {
  904.             if (*s == '\\')
  905.             {
  906.                 fprintf(output_file, "\\\\");
  907.                 if (*++s == '\\')
  908.                 fprintf(output_file, "\\\\");
  909.                 else
  910.                 putc(*s, output_file);
  911.             }
  912.             else
  913.                 putc(*s, output_file);
  914.             }
  915.             fprintf(output_file, "'\",");
  916.         }
  917.         }
  918.         else
  919.         {
  920.         k = strlen(s) + 3;
  921.         j += k;
  922.         if (j > 80)
  923.         {
  924.             if (!rflag) ++outline;
  925.             putc('\n', output_file);
  926.             j = k;
  927.         }
  928.         putc('"', output_file);
  929.         do { putc(*s, output_file); } while (*++s);
  930.         fprintf(output_file, "\",");
  931.         }
  932.     }
  933.     else
  934.     {
  935.         j += 2;
  936.         if (j > 80)
  937.         {
  938.         if (!rflag) ++outline;
  939.         putc('\n', output_file);
  940.         j = 2;
  941.         }
  942.         fprintf(output_file, "0,");
  943.     }
  944.     }
  945.     if (!rflag) outline += 2;
  946.     fprintf(output_file, "\n};\n");
  947.     FREE(symnam);
  948.  
  949.     if (!rflag) ++outline;
  950.     fprintf(output_file, "char *yyrule[] = {\n");
  951.     for (i = 2; i < nrules; ++i)
  952.     {
  953.     fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]);
  954.     for (j = rrhs[i]; ritem[j] > 0; ++j)
  955.     {
  956.         s = symbol_name[ritem[j]];
  957.         if (s[0] == '"')
  958.         {
  959.         fprintf(output_file, " \\\"");
  960.         while (*++s != '"')
  961.         {
  962.             if (*s == '\\')
  963.             {
  964.             if (s[1] == '\\')
  965.                 fprintf(output_file, "\\\\\\\\");
  966.             else
  967.                 fprintf(output_file, "\\\\%c", s[1]);
  968.             ++s;
  969.             }
  970.             else
  971.             putc(*s, output_file);
  972.         }
  973.         fprintf(output_file, "\\\"");
  974.         }
  975.         else if (s[0] == '\'')
  976.         {
  977.         if (s[1] == '"')
  978.             fprintf(output_file, " '\\\"'");
  979.         else if (s[1] == '\\')
  980.         {
  981.             if (s[2] == '\\')
  982.             fprintf(output_file, " '\\\\\\\\");
  983.             else
  984.             fprintf(output_file, " '\\\\%c", s[2]);
  985.             s += 2;
  986.             while (*++s != '\'')
  987.             putc(*s, output_file);
  988.             putc('\'', output_file);
  989.         }
  990.         else
  991.             fprintf(output_file, " '%c'", s[1]);
  992.         }
  993.         else
  994.         fprintf(output_file, " %s", s);
  995.     }
  996.     if (!rflag) ++outline;
  997.     fprintf(output_file, "\",\n");
  998.     }
  999.  
  1000.     if (!rflag) outline += 2;
  1001.     fprintf(output_file, "};\n#endif\n");
  1002. }
  1003.  
  1004.  
  1005. output_stype()
  1006. {
  1007.     if (!unionized && ntags == 0)
  1008.     {
  1009.     outline += 3;
  1010.     fprintf(code_file, "#ifndef YYSTYPE\ntypedef int YYSTYPE;\n#endif\n");
  1011.     }
  1012. }
  1013.  
  1014.  
  1015. output_trailing_text()
  1016. {
  1017.     register int c, last;
  1018.     register FILE *in, *out;
  1019.  
  1020.     if (line == 0)
  1021.     return;
  1022.  
  1023.     in = input_file;
  1024.     out = code_file;
  1025.     c = *cptr;
  1026.     if (c == '\n')
  1027.     {
  1028.     ++lineno;
  1029.     if ((c = getc(in)) == EOF)
  1030.         return;
  1031.     if (!lflag)
  1032.     {
  1033.         ++outline;
  1034.         fprintf(out, line_format, lineno, input_file_name);
  1035.     }
  1036.     if (c == '\n')
  1037.         ++outline;
  1038.     putc(c, out);
  1039.     last = c;
  1040.     }
  1041.     else
  1042.     {
  1043.     if (!lflag)
  1044.     {
  1045.         ++outline;
  1046.         fprintf(out, line_format, lineno, input_file_name);
  1047.     }
  1048.     do { putc(c, out); } while ((c = *++cptr) != '\n');
  1049.     ++outline;
  1050.     putc('\n', out);
  1051.     last = '\n';
  1052.     }
  1053.  
  1054.     while ((c = getc(in)) != EOF)
  1055.     {
  1056.     if (c == '\n')
  1057.         ++outline;
  1058.     putc(c, out);
  1059.     last = c;
  1060.     }
  1061.  
  1062.     if (last != '\n')
  1063.     {
  1064.     ++outline;
  1065.     putc('\n', out);
  1066.     }
  1067.     if (!lflag)
  1068.     fprintf(out, line_format, ++outline + 1, code_file_name);
  1069. }
  1070.  
  1071.  
  1072. output_semantic_actions()
  1073. {
  1074.     register int c, last;
  1075.     register FILE *out;
  1076.  
  1077.     fclose(action_file);
  1078.     action_file = fopen(action_file_name, "r");
  1079.     if (action_file == NULL)
  1080.     open_error(action_file_name);
  1081.  
  1082.     if ((c = getc(action_file)) == EOF)
  1083.     return;
  1084.  
  1085.     out = code_file;
  1086.     last = c;
  1087.     if (c == '\n')
  1088.     ++outline;
  1089.     putc(c, out);
  1090.     while ((c = getc(action_file)) != EOF)
  1091.     {
  1092.     if (c == '\n')
  1093.         ++outline;
  1094.     putc(c, out);
  1095.     last = c;
  1096.     }
  1097.  
  1098.     if (last != '\n')
  1099.     {
  1100.     ++outline;
  1101.     putc('\n', out);
  1102.     }
  1103.  
  1104.     if (!lflag)
  1105.     fprintf(out, line_format, ++outline + 1, code_file_name);
  1106. }
  1107.  
  1108.  
  1109. free_itemsets()
  1110. {
  1111.     register core *cp, *next;
  1112.  
  1113.     FREE(state_table);
  1114.     for (cp = first_state; cp; cp = next)
  1115.     {
  1116.     next = cp->next;
  1117.     FREE(cp);
  1118.     }
  1119. }
  1120.  
  1121.  
  1122. free_shifts()
  1123. {
  1124.     register shifts *sp, *next;
  1125.  
  1126.     FREE(shift_table);
  1127.     for (sp = first_shift; sp; sp = next)
  1128.     {
  1129.     next = sp->next;
  1130.     FREE(sp);
  1131.     }
  1132. }
  1133.  
  1134.  
  1135.  
  1136. free_reductions()
  1137. {
  1138.     register reductions *rp, *next;
  1139.  
  1140.     FREE(reduction_table);
  1141.     for (rp = first_reduction; rp; rp = next)
  1142.     {
  1143.     next = rp->next;
  1144.     FREE(rp);
  1145.     }
  1146. }
  1147.